home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / compstol / cmpsttl1.lha / CompositeTool / v1.1.dist / HDF / dfp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-08  |  10.1 KB  |  338 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.00
  4. *                December, 1989
  5. *
  6. * NCSA HDF Version 3.00 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. /*-----------------------------------------------------------------------------
  23.  * File:    dfp.c
  24.  * Purpose: read and write palettes
  25.  * Invokes: df.c
  26.  * Contents: 
  27.  *  DFPgetpal: retrieve next palette
  28.  *  DFPputpal: write palette to file
  29.  *  DFPaddpal: add palette to file
  30.  *  DFPnpals: number of palettes in HDF file
  31.  *  DFPreadref: get palette with this reference number next
  32.  *  DFPwriteref: put palette with this reference number next
  33.  *  DFPrestart: forget info about last file accessed - restart from beginning
  34.  *  DFPlastref: return reference number of last element read or written
  35.  *  DFPIopen: open/reopen file
  36.  *---------------------------------------------------------------------------*/
  37.  
  38. #include "df.h"
  39.  
  40. static uint16 Readref=0;
  41. static uint16 Writeref=0;
  42. static uint16 Refset=0;        /* Ref of palette to get next */
  43. static uint16 Lastref = 0;    /* Last ref read/written */
  44.  
  45. static char Lastfile[DF_MAXFNLEN]; /* last file opened */
  46.  
  47. #ifndef VMS
  48. DF *DFPIopen();
  49. #else /*VMS*/
  50. DF *_DFPIopen();
  51. #endif
  52.  
  53.  
  54. /*-----------------------------------------------------------------------------
  55.  * Name:    DFPgetpal
  56.  * Purpose: get next palette from file
  57.  * Inputs:  filename: name of HDF file
  58.  *          palette: 768 byte space to read palette into
  59.  * Returns: 0 on success, -1 on failure with DFerror set
  60.  *          palette in pal
  61.  * Users:   HDF HLL users, utilities, other routines
  62.  * Invokes: DFPIopen, DFIerr, DFclose, DFgetelement
  63.  *---------------------------------------------------------------------------*/
  64.  
  65. int DFPgetpal(filename, palette)
  66. char *filename;
  67. char *palette;
  68. {
  69.     DF *dfile;
  70.     int cdd, ret;
  71.     DFdle *dlep;
  72.  
  73.     DFerror = DFE_NOERROR;
  74.  
  75.     if (!palette) {
  76.         DFerror = DFE_BADPTR;
  77.         return(-1);
  78.     }
  79.     dfile = DFPIopen(filename, DFACC_READ);
  80.     if (dfile == NULL) return(-1);
  81.  
  82.     if (Refset)
  83.         ret = DFIfind(dfile, DFTAG_IP8, Refset, 1,(uint16) 0, (uint16) 0,
  84.               &dlep, &cdd);
  85.     else
  86.         ret = DFIfind(dfile,DFTAG_IP8,0, !Readref, DFTAG_IP8,Readref,
  87.               &dlep,&cdd);
  88.  
  89.     Refset = 0;
  90.     if (ret<0) return(DFIerr(dfile)); /* on error, close file and return -1 */
  91.  
  92.     Readref = dlep->dd[cdd].ref; /* ref of element to read */
  93.  
  94.         /* read palette */
  95.     if (DFgetelement(dfile, DFTAG_IP8, Readref, palette)<0)
  96.             return(DFIerr(dfile));
  97.  
  98.     Lastref = Readref;
  99.  
  100.     return(DFclose(dfile));
  101. }
  102.  
  103.  
  104. /*-----------------------------------------------------------------------------
  105.  * Name:    DFPputpal
  106.  * Purpose: Write palette to file
  107.  * Inputs:  filename: name of HDF file
  108.  *          palette: palette to be written to file
  109.  *          overwrite: if 1, overwrite last palette read or written
  110.  *                     if 0, write it as a fresh palette
  111.  *          filemode: if "a", append palette to file
  112.  *                    if "w", create new file
  113.  * Returns: 0 on success, -1 on failure with DFerror set
  114.  * Users:   HDF users, programmers, utilities
  115.  * Invokes: DFPIopen, DFclose, DFputelement, DFIerr
  116.  * Remarks: To overwrite, the filename must be the same as for the previous
  117.  *          call
  118.  *---------------------------------------------------------------------------*/
  119.  
  120. int DFPputpal(filename, palette, overwrite, filemode)
  121. char *filename;
  122. char *palette;
  123. int overwrite;
  124. char *filemode;
  125. {
  126.     DF *dfile;
  127.  
  128.     DFerror = DFE_NOERROR;
  129.  
  130.     if (!palette) {
  131.         DFerror = DFE_BADPTR;
  132.         return(-1);
  133.     }
  134.  
  135.     if (overwrite && strcmp(filename, Lastfile)) {
  136.         DFerror = DFE_BADCALL;
  137.         return(-1);
  138.     }
  139.  
  140.     dfile = DFPIopen(filename, (*filemode=='w') ? DFACC_CREATE : DFACC_WRITE);
  141.     if (dfile==NULL) return(-1);
  142.  
  143.         /* if we want to overwrite, Lastref is the ref to write.  If not, if
  144.             Writeref is set, we use that ref.  If not we get a fresh ref. The
  145.             ref to write is placed in Lastref */
  146.     if (!overwrite) Lastref = Writeref ? Writeref : DFnewref(dfile);
  147.     if (Lastref == 0) return(-1);
  148.  
  149.     Writeref = 0;           /* don't know ref to write after this */
  150.  
  151.         /* write out palette */
  152.     if (DFputelement(dfile, DFTAG_IP8, Lastref, palette, (int32) 768)<0)
  153.             return(DFIerr(dfile));
  154.  
  155.     return(DFclose(dfile));
  156. }
  157.  
  158.  
  159. /*-----------------------------------------------------------------------------
  160.  * Name:    DFPaddpal
  161.  * Purpose: Add palette to file
  162.  * Inputs:  filename: name of HDF file
  163.  *          palette: palette to be written to file
  164.  * Returns: 0 on success, -1 on failure with DFerror set
  165.  * Users:   HDF users, programmers, utilities
  166.  * Invokes: DFPputpal
  167.  *---------------------------------------------------------------------------*/
  168.  
  169. int DFPaddpal(filename, palette)
  170. char *filename;
  171. char *palette;
  172. {
  173.  
  174.     return(DFPputpal(filename, palette, 0, "a"));
  175. }
  176.  
  177.  
  178. /*-----------------------------------------------------------------------------
  179.  * Name:    DFPnpals
  180.  * Purpose: How many palettes are present in this file?
  181.  * Inputs:  filename: name of HDF file
  182.  * Returns: number of palettes on success, -1 on failure with DFerror set
  183.  * Users:   HDF programmers, other routines and utilities
  184.  * Invokes: DFPIopen, DFclose, DFnumber
  185.  *---------------------------------------------------------------------------*/
  186.  
  187. int DFPnpals(filename)
  188. char *filename;
  189. {
  190.     DF *dfile;
  191.     int npals=0;
  192.  
  193.     DFerror = DFE_NOERROR;
  194.  
  195.     /* should use reopen if same file as last time - more efficient */
  196.     dfile = DFPIopen(filename, DFACC_READ);
  197.     if (dfile==NULL) return(-1);
  198.  
  199.     npals = DFnumber(dfile, DFTAG_IP8);    /* count number of IPs */
  200.     if (npals<0) return(DFIerr(dfile));
  201.  
  202.     if (DFclose(dfile)<0) return(-1);
  203.     return(npals);
  204. }
  205.  
  206.  
  207. /*-----------------------------------------------------------------------------
  208.  * Name:    DFPreadref
  209.  * Purpose: Set ref of palette to get next
  210.  * Inputs:  filename: file to which this applies
  211.  *          ref: reference number of next get
  212.  * Returns: 0 on success, -1 on failure
  213.  * Users:   HDF programmers, other routines and utilities
  214.  * Invokes: DFPIopen, DFIfind, DFclose
  215.  * Remarks: checks if palette with this ref exists
  216.  *---------------------------------------------------------------------------*/
  217.  
  218. int DFPreadref(filename, ref)
  219. char *filename;
  220. uint16 ref;
  221. {
  222.     DF *dfile;
  223.     int cdd;
  224.     DFdle *dlep;
  225.  
  226.     DFerror = DFE_NOERROR;
  227.  
  228.     dfile = DFPIopen(filename, DFACC_READ);
  229.     if (dfile==NULL) return(-1);
  230.  
  231.     if (DFIfind(dfile, DFTAG_IP8, ref, 1, 0, 0, &dlep, &cdd)<0)
  232.         return(DFIerr(dfile));
  233.  
  234.     Refset = ref;
  235.     return(DFclose(dfile));
  236. }
  237.  
  238.  
  239. /*-----------------------------------------------------------------------------
  240.  * Name:    DFPwriteref
  241.  * Purpose: Set ref of palette to put next
  242.  * Inputs:  filename: file to which this applies
  243.  *          ref: reference number of next put
  244.  * Returns: 0 on success, -1 on failure
  245.  * Users:   HDF programmers, other routines and utilities
  246.  * Invokes: none
  247.  *---------------------------------------------------------------------------*/
  248.  
  249. /* shut lint up */
  250. /* ARGSUSED */
  251. int DFPwriteref(filename, ref)
  252. char *filename;
  253. uint16 ref;
  254. {
  255.     DFerror = DFE_NOERROR;
  256.  
  257.     Writeref = ref;
  258.     return(0);
  259. }
  260.  
  261.  
  262.  
  263. /*-----------------------------------------------------------------------------
  264.  * Name:    DFPrestart
  265.  * Purpose: Do not remember info about file - get again from first palette
  266.  * Inputs:  none
  267.  * Returns: 0 on success
  268.  * Users:   HDF programmers
  269.  * Remarks: Just reset Lastfile to NULL
  270.  *---------------------------------------------------------------------------*/
  271.  
  272. int DFPrestart()
  273. {
  274.  
  275.     Lastfile[0] = '\0';
  276.     return(0);
  277. }
  278.  
  279.  
  280. /*-----------------------------------------------------------------------------
  281.  * Name:    DFPlastref
  282.  * Purpose: Return last ref written or read
  283.  * Inputs:  none
  284.  * Globals: Lastref
  285.  * Returns: ref on success, -1 on error with DFerror set
  286.  * Users:   HDF users, utilities, other routines
  287.  * Invokes: none
  288.  * Method:  return Lastref
  289.  * Remarks: none
  290.  *---------------------------------------------------------------------------*/
  291.  
  292. int DFPlastref()
  293. {
  294.  
  295.     return(Lastref);
  296. }
  297.  
  298.  
  299.  
  300. /******************************************************************************/
  301. /*----------------------- Internal routines ---------------------------------*/
  302. /******************************************************************************/
  303.  
  304.  
  305. /*-----------------------------------------------------------------------------
  306.  * Name:    DFPIopen
  307.  * Purpose: open or reopen a file
  308.  * Inputs:  filename: name of file to open
  309.  *          access : access mode
  310.  * Returns: file pointer on success, NULL on failure with DFerror set
  311.  * Users:   HDF systems programmers, other DFP routines
  312.  * Invokes: DFopen
  313.  * Remarks: This is a hook for someday providing more efficient ways to
  314.  *          reopen a file, to avoid re-reading all the headers
  315.  *---------------------------------------------------------------------------*/
  316.  
  317. DF *DFPIopen(filename, access)
  318. char *filename;
  319. int access;
  320. {
  321.  
  322.     DF *dfile;
  323.  
  324.         /* use reopen if same file as last time - more efficient */
  325.     if (strncmp(Lastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  326.                                     /* treat create as different file */
  327.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  328.         Refset = 0;         /* no ref to get set for this file */
  329.         Readref = 0;
  330.     }
  331.     else
  332.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  333.  
  334.     DFIstrncpy(Lastfile, filename, DF_MAXFNLEN);
  335.         /* remember filename, so reopen may be used next time if same file */
  336.     return(dfile);
  337. }
  338.